home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / source / snip9503 / mouse.c < prev    next >
C/C++ Source or Header  |  1995-03-14  |  9KB  |  363 lines
  1. /*
  2. ** A series of routines to provide access to MicroSoft (and compatible)
  3. ** mice.  Consult your mouse documentation for detailed information regarding
  4. ** each mouse driver function.
  5. **
  6. ** by Bob Jarvis w/ modifications by Bob Stout & Bruce Wedding
  7. */
  8.  
  9. #include <dos.h>
  10. #include "mouse.h"
  11.  
  12. int mouse_present = 0;  /* globally visible */
  13.  
  14. #define DOS_INT 0x21
  15.  
  16. #if defined(__ZTC__) && defined(DOS386)
  17.   #define MOUSE(workregs) int86_real(MSMOUSE,&workregs,&workregs)
  18.   #define MOUSEX(workregs,segs) int86x_real(DOS_INT,&workregs,&workregs,&sregs)
  19. #else
  20.   #define MOUSE(workregs) int86(MSMOUSE,&workregs,&workregs)
  21.   #define MOUSEX(workregs,segs) int86x(DOS_INT,&workregs,&workregs,&sregs)
  22. #endif
  23.  
  24. /*
  25. ** Uses driver function 0 to initialize the mouse software to its default
  26. ** settings.  If no mouse is present it returns 0.  If a mouse is present, it
  27. ** returns -1, and places the value of the mouse type (2 = MicroSoft,
  28. ** 3 = Mouse Systems, other values are possible) in *mousetype.  Also
  29. ** initializes the global variable mouse_present (0 = no mouse, !0 = mouse
  30. ** is available).
  31. */
  32.  
  33. int ms_reset(int *mousetype)
  34. {
  35.       union REGS workregs;
  36.       struct SREGS sregs;
  37.  
  38.       /* check the vector     */
  39.  
  40.       segread (&sregs);
  41.       workregs.h.ah = 0x35;     /* DOS get vector */
  42.       workregs.h.al = 0x33;     /* mouse vector   */
  43.       intdosx(&workregs, &workregs, &sregs);
  44.  
  45.       /* ES:BX now contains the pointer to the interrupt handler */
  46.  
  47.       if (sregs.es == 0 && workregs.x.bx == 0)
  48.             return mouse_present = 0;
  49.  
  50.       workregs.x.ax = 0;
  51.       MOUSE(workregs);
  52.       *mousetype = workregs.x.bx;
  53.       mouse_present = workregs.x.ax;
  54.       return(mouse_present);
  55. }
  56.  
  57. /*
  58. ** Makes the mouse cursor visible.
  59. */
  60.  
  61. void ms_show_cursor(void)
  62. {
  63.       union REGS workregs;
  64.  
  65.       workregs.x.ax = 1;
  66.       MOUSE(workregs);
  67. }
  68.  
  69. /*
  70. ** Hides the mouse cursor.  Should be called before changing any portion of
  71. ** the screen under the mouse cursor.
  72. */
  73.  
  74. void ms_hide_cursor(void)
  75. {
  76.       union REGS workregs;
  77.  
  78.       workregs.x.ax = 2;
  79.       MOUSE(workregs);
  80. }
  81.  
  82. /*
  83. ** Obtains information about the mouse position and button status.
  84. ** Places the current horizontal and vertical positions in *horizpos and
  85. ** *vertpos, respectively.  Returns the mouse button status, which is
  86. ** mapped at the bit level as follows:
  87. **    Bit 0 - left button    \
  88. **    Bit 1 - right button    >-- 0 = button up, 1 = button down
  89. **    Bit 2 - middle button  /
  90. */
  91.  
  92. int ms_get_mouse_pos(int *horizpos, int *vertpos) /* Returns button status */
  93. {
  94.       union REGS workregs;
  95.  
  96.       workregs.x.ax = 3;
  97.       MOUSE(workregs);
  98.       *horizpos = workregs.x.cx;
  99.       *vertpos  = workregs.x.dx;
  100.       return(workregs.x.bx);
  101. }
  102.  
  103. /*
  104. ** Moves the mouse cursor to a new position.
  105. */
  106.  
  107. void ms_set_mouse_pos(int horizpos, int vertpos)
  108. {
  109.       union REGS workregs;
  110.  
  111.       workregs.x.ax = 4;
  112.       workregs.x.cx = horizpos;
  113.       workregs.x.dx = vertpos;
  114.       MOUSE(workregs);
  115. }
  116.  
  117. /*
  118. ** Obtains information about the last time the specified button
  119. ** (0 = left, 1 = right, 2 = middle) was pressed.  Returns the current
  120. ** button status (same format as return from ms_get_mouse_pos() above).
  121. */
  122.  
  123. int ms_button_press_status(int  button,
  124.                            int *press_count,
  125.                            int *column,
  126.                            int *row)
  127. {
  128.       union REGS workregs;
  129.  
  130.       workregs.x.ax = 5;
  131.       workregs.x.bx = button;
  132.       MOUSE(workregs);
  133.       *press_count = workregs.x.bx;
  134.       *column = workregs.x.cx;
  135.       *row = workregs.x.dx;
  136.       return(workregs.x.ax);
  137. }
  138.  
  139. /*
  140. ** Similar to above but obtains information about the last release of the
  141. ** specified button.
  142. */
  143.  
  144. int ms_button_release_status(int  button,
  145.                              int *release_count,
  146.                              int *column,
  147.                              int *row)
  148. {
  149.       union REGS workregs;
  150.  
  151.       workregs.x.ax = 6;
  152.       workregs.x.bx = button;
  153.       MOUSE(workregs);
  154.       *release_count = workregs.x.bx;
  155.       *column = workregs.x.cx;
  156.       *row = workregs.x.dx;
  157.       return(workregs.x.ax);
  158. }
  159.  
  160. /*
  161. ** Forces the mouse cursor to remain within the range specified.
  162. */
  163.  
  164. void ms_restrict_horiz(int min, int max)
  165. {
  166.       union REGS workregs;
  167.  
  168.       workregs.x.ax = 7;
  169.       workregs.x.cx = min;
  170.       workregs.x.dx = max;
  171.       MOUSE(workregs);
  172. }
  173.  
  174. /*
  175. ** Forces the mouse cursor to remain within the range specified.
  176. */
  177.  
  178. void ms_restrict_vert(int min, int max)
  179. {
  180.       union REGS workregs;
  181.  
  182.       workregs.x.ax = 8;
  183.       workregs.x.cx = min;
  184.       workregs.x.dx = max;
  185.       MOUSE(workregs);
  186. }
  187.  
  188. void ms_define_window(int left, int top, int right, int bottom)
  189. {
  190.       ms_restrict_horiz(left,right);
  191.       ms_restrict_vert(top,bottom);
  192. }
  193.  
  194. /*
  195. ** Allows the user to set the graphics cursor to a new shape.  Check your
  196. ** mouse reference manual for full information about the use of this function.
  197. */
  198.  
  199. void ms_set_graphics_cursor(int      horiz_hotspot,
  200.                             int      vert_hotspot,
  201.                             unsigned seg_shape_tables,
  202.                             unsigned offset_shape_tables)
  203. {
  204.       union REGS workregs;
  205.       struct SREGS segregs;
  206.  
  207.       workregs.x.ax = 9;
  208.       workregs.x.bx = horiz_hotspot;
  209.       workregs.x.cx = vert_hotspot;
  210.       workregs.x.dx = offset_shape_tables;
  211.       segregs.es  = seg_shape_tables;
  212.       MOUSEX(workregs, segregs);
  213. }
  214.  
  215. /*
  216. ** Selects either the software or hardware cursor and sets the start and stop
  217. ** scan lines (for the hardware cursor) or the screen and cursor masks (for
  218. ** the software cursor).  Consult your mouse reference for more information.
  219. */
  220.  
  221. void ms_set_text_cursor(int type, int screen_mask, int cursor_mask)
  222. {
  223.       union REGS workregs;
  224.  
  225.       workregs.x.ax = 10;
  226.       workregs.x.bx = type;
  227.       workregs.x.cx = screen_mask;
  228.       workregs.x.dx = cursor_mask;
  229.       MOUSE(workregs);
  230. }
  231.  
  232. /*
  233. ** Obtains the horizontal and vertical raw motion counts since the last
  234. ** request.
  235. */
  236.  
  237. void ms_read_motion_counters(int *horiz, int *vert)
  238. {
  239.       union REGS workregs;
  240.  
  241.       workregs.x.ax = 11;
  242.       MOUSE(workregs);
  243.       *horiz = workregs.x.cx;
  244.       *vert  = workregs.x.dx;
  245. }
  246.  
  247. /*
  248. ** Sets up a subroutine to be called when a given event occurs.
  249. ** NOTE: Use with extreme care.  The function whose address is provided MUST
  250. **    terminate with a far return (i.e. must be compiled using large model).
  251. **    Also, no DOS or BIOS services may be used, as the user-defined function
  252. **    is (in effect) an extension to an interrupt service routine.
  253. */
  254.  
  255. void ms_set_event_subroutine(int      mask,
  256.                              unsigned seg_routine,
  257.                              unsigned offset_routine)
  258. {
  259.       union REGS workregs;
  260.       struct SREGS segregs;
  261.  
  262.       workregs.x.ax = 12;
  263.       workregs.x.cx = mask;
  264.       workregs.x.dx = offset_routine;
  265.       segregs.es  = seg_routine;
  266.       MOUSEX(workregs, segregs);
  267. }
  268.  
  269. /*
  270. ** Turns light pen emulation mode on.
  271. */
  272.  
  273. void ms_light_pen_on(void)
  274. {
  275.       union REGS workregs;
  276.  
  277.       workregs.x.ax = 13;
  278.       MOUSE(workregs);
  279. }
  280.  
  281. /*
  282. ** turns light pen emulation mode off.
  283. */
  284.  
  285. void ms_light_pen_off(void)
  286. {
  287.       union REGS workregs;
  288.  
  289.       workregs.x.ax = 14;
  290.       MOUSE(workregs);
  291. }
  292.  
  293. /*
  294. ** Sets the sensitivity of the mouse.  Defaults are 8 and 16 for horizontal
  295. ** and vertical sensitivity (respectively).
  296. */
  297.  
  298. void ms_set_sensitivity(int horiz, int vert)
  299. {
  300.       union REGS workregs;
  301.  
  302.       workregs.x.ax = 15;
  303.       workregs.x.cx = horiz;
  304.       workregs.x.dx = vert;
  305.       MOUSE(workregs);
  306. }
  307.  
  308. /*
  309. ** Sets up a region of the screen inside of which the mouse cursor will
  310. ** automatically be 'hidden'.
  311. */
  312.  
  313. void ms_protect_area(int left, int top, int right, int bottom)
  314. {
  315.       union REGS workregs;
  316.  
  317.       workregs.x.ax = 16;
  318.       workregs.x.cx = left;
  319.       workregs.x.dx = top;
  320.       workregs.x.si = right;
  321.       workregs.x.di = bottom;
  322.       MOUSE(workregs);
  323. }
  324.  
  325. /*
  326. * Similar to ms_set_graphics_cursor() but allows a larger cursor.  Consult
  327. ** your mouse documentation for information on how to use this function.
  328. */
  329.  
  330. int ms_set_large_graphics_cursor(int      width,
  331.                                  int      height,
  332.                                  int      horiz_hotspot,
  333.                                  int      vert_hotspot,
  334.                                  unsigned seg_shape_tables,
  335.                                  unsigned offset_shape_tables)
  336. {
  337.       union REGS workregs;
  338.       struct SREGS segregs;
  339.  
  340.       workregs.x.ax = 18;
  341.       workregs.x.bx = (width << 8) + horiz_hotspot;
  342.       workregs.x.cx = (height << 8) + vert_hotspot;
  343.       workregs.x.dx = offset_shape_tables;
  344.       segregs.es  = seg_shape_tables;
  345.       MOUSEX(workregs, segregs);
  346.       if(workregs.x.ax == (unsigned)-1)
  347.             return(workregs.x.ax); /* Return -1 if function 18 supported */
  348.       else  return(0);             /* else return 0                      */
  349. }
  350.  
  351. /*
  352. ** Sets the threshold value for doubling cursor motion.  Default value is 64.
  353. */
  354.  
  355. void ms_set_doublespeed_threshold(int speed)
  356. {
  357.       union REGS workregs;
  358.  
  359.       workregs.x.ax = 19;
  360.       workregs.x.dx = speed;
  361.       MOUSE(workregs);
  362. }
  363.